/****************************************************************
 * Fulguro
 * Copyright (C) 2004 Christophe Clienti
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 ***************************************************************/

%module (docstring="Fulguro Core Module") flgrcore
%include ../common/common.i

 /*********************** Include for wrapper **********************/

%inline %{
#include <string.h>
#include <flgrCoreTypes.h>
#include <flgrCoreErrors.h>
#include <flgrCoreData.h>
#include <flgrImageIO.h>
#include <flgrImageColorSpace.h>
#include <flgrCoreSlideWindow.h>
#include <flgrCoreDataIO.h>
#include <flgrCoreNhbFill.h>
#include <flgrCoreCopy.h>
#include <flgrCoreThreads.h>
#include <flgrCoreThreadsAuto.h>
#include <flgrCoreCompare.h>
#include <flgrCoreGeometry.h>
#include <flgrCoreNhbManage.h>
#include <flgrCoreMeasureVector.h>
#include <flgrCoreArithVector.h>
#include <flgrCoreVector.h>
#include <flgrCoreRoI.h>
#include <flgrCoreSampling.h>
#include <flgrCoreSystem.h>

#include "flgrcore_ext.h"

  %}

%include "flgrcore_vector.i"
%include "flgrcore_1d.i"
%include "flgrcore_2d.i"
%include "flgrcore_container.i"


/**********************************************************************************************
 **********************************************************************************************
 * FLGR_Data2D Functions exports
 **********************************************************************************************
 **********************************************************************************************/

/*********************** Documentation ***********************/




/*********************** Declaration ***********************/
%feature("autodoc","""
[return] string\n
Get supported image information
""") flgr_get_supported_image_format;
char *flgr_get_supported_image_format(void);


%feature("autodoc","""
[return] integer\n
Get the number of available processors
""") flgr_get_processor_numbers;
int flgr_get_processor_numbers(void);

%feature("autodoc","""
[return] string\n
Get fulguro version
""") flgr_get_version;
char *flgr_get_version(void);

%feature("autodoc","""
[return] integer\n
Return 1 if system is little endian
""") flgr_system_is_little_endian;
int flgr_system_is_little_endian(void);


%feature("autodoc","""
[in] Type (eg FLGR_UINT8, ...)
[return] interger \n
return bit per pixel for the given type.
""") flgr_get_bps_from_type;
int flgr_get_bps_from_type(FLGR_Type type);

%feature("autodoc","""
[in] Type (eg FLGR_UINT8, ...)
[return] interger \n
return the byte size of the given type.
""") flgr_get_sizeof;
int flgr_get_sizeof(FLGR_Type type);

%feature("autodoc","""
[in] Type (eg FLGR_UINT8, ...)
[return] FLGR_Ret\n
Test if a type exist.
""") flgr_is_data_type_valid;
FLGR_Ret flgr_is_data_type_valid(FLGR_Type type);

%feature("autodoc","""
[in] coord value
[in] length of the axis
[return] interger \n
return a coordinate value to prevent access out of the array. This function
allows to emulate an unfold operation around the data border.
""") flgr_normalize_coordinate;
int flgr_normalize_coordinate(int axis_coord, int axis_length);



%feature("autodoc","""
[in] type enum
[return] string\n
return a string containing type.
""")flgr_get_type_string;
char *flgr_get_type_string(FLGR_Type type);


%feature("autodoc","""
[in] type enum
[return] string\n
return a string containing shape.
""")flgr_get_shapestring;
char *flgr_get_shape_string(FLGR_Shape shape);





/************ Image load/save ****************/
%feature("autodoc","""
[in] file name string
[in] how many byte to skip header
[in] height
[in] width
[in] how many sample per pixel
[in] data type : FLGR_UINT8, ...
[return] FLGR_Data2D object \n
load a raw image
""") flgr2d_load_raw_file;
FLGR_Data2D *flgr2d_load_raw_file(char *filename, int byte_offset, int size_y, int size_x, int spp, FLGR_Type type);

%feature("autodoc","""
[in] file name string
[in] height
[in] width
[in] how many sample per pixel
[in] data type : FLGR_UINT8, ...
[return] FLGR_Data2D object \n
load a raw image
""") flgr2d_load_raw_file;
FLGR_Data2D *flgr2d_load_text_file(char *filename, int size_y, int size_x, int spp, FLGR_Type type);

%feature("autodoc","""
[in] file name string
[return] FLGR_Data2D object \n
load a PGM brut (P5) or text (P2) image (8 bits or 16 bits).
""") flgr2d_load_pgm;
FLGR_Data2D *flgr2d_load_pgm(char *filename);

%feature("autodoc","""
[in] file name string
[return] FLGR_Data2D object \n
load a bmp file.
""") flgr2d_load_bmp;
FLGR_Data2D *flgr2d_load_bmp(char *filename);

%feature("autodoc","""
[in] file name string
[return] FLGR_Data2D object \n
load a png image.
""") flgr2d_load_png;
FLGR_Data2D *flgr2d_load_png(char *filename);

%feature("autodoc","""
[in] file name string
[return] FLGR_Data2D object \n
load a jpeg image.
""") flgr2d_load_jpeg;
FLGR_Data2D *flgr2d_load_jpeg(char *filename);

%feature("autodoc","""
[in] file name string
[return] FLGR_Data2D object \n
load a tiff image.
""") flgr2d_load_tiff;
FLGR_Data2D *flgr2d_load_tiff(char *filename);

%feature("autodoc","""
[in] file name string
[return] string \n
get tiff file info.
""") flgr2d_load_tiff_info;
char *flgr2d_load_tiff_info(char *filename);

%feature("autodoc","""
[in] Image 2D
[in] File name string
[in] format 2 for P2 or 5 for P5 (default)
[return] FLGR_RET_OK,... \n
Store image (8 bits or 16 bits unsigned)
""") flgr2d_save_pgm;
FLGR_Ret flgr2d_save_pgm(FLGR_Data2D *img, char *filename, int format = 5);

%feature("autodoc","""
[in] Image 2D
[in] File name string
[return] FLGR_RET_OK,... \n
Store image in a png file
""") flgr2d_save_png;
FLGR_Ret flgr2d_save_png(FLGR_Data2D *img, char *filename);

%feature("autodoc","""
[in] Image 2D
[in] File name string
[in] Quality [0,100] (default value : 100)
[return] FLGR_RET_OK,... \n
Store image in a jpeg file
""") flgr2d_save_jpeg;
FLGR_Ret flgr2d_save_jpeg(FLGR_Data2D *img, char *filename, int quality=100);


%feature("autodoc","""
[in] Image 2D
[in] File name string
[in] Quality [0,100] (default value : 100)
[return] FLGR_RET_OK,... \n
Store image in a tiff file
""") flgr2d_save_tiff;
FLGR_Ret flgr2d_save_tiff(FLGR_Data2D *img, char *filename, int quality=100);



%feature("autodoc","""
[out] FLGR_Data1D
[in] FLGR_Shape
[in] Shape width
[in] Shape height
[return] FLGR_Ret\n
The shape could be : FLGR_LINE
Draw the shape in the Neighborhood definition (shape is centered)
""") flgr1d_fill_neighborhood;
FLGR_Ret flgr1d_fill_neighborhood(FLGR_Data1D *nhb, FLGR_Shape shape, int width);

%feature("autodoc","""
[out] FLGR_Data2D
[in] FLGR_Shape
[in] Shape width
[in] Shape height
[return] FLGR_Ret\n
The shape could be : FLGR_RECT, FLGR_HEX, FLGR_ELLIPSE, FLGR_CROSS1,
 FLGR_CROSS2, FLGR_DISC, FLGR_BSLASH, FLGR_SLASH, FLGR_USER_SHAPE.
Draw the shape in the Neighborhood definition (shape is centered)
""") flgr2d_fill_neighborhood;
FLGR_Ret flgr2d_fill_neighborhood(FLGR_Data2D *nhb, FLGR_Shape shape, int width, int height);

%feature("autodoc","""
[in] FLGR_Data1D destination used by a processing function
[in] FLGR_Data1D source used by a processing function
[return] FLGR_MorphoOptim\n
Find optimization available for a given destination and source data 1D
""") flgr1d_get_optimization_available;
FLGR_MorphoOptim flgr1d_get_optimization_available(FLGR_Data1D *datdest, FLGR_Data1D *datsrc, FLGR_Data1D *nhb);

%feature("autodoc","""
[in] FLGR_Data2D destination used by a processing function
[in] FLGR_Data2D source used by a processing function
[return] FLGR_MorphoOptim\n
Find optimization available for a given destination and source data 2D
""") flgr2d_get_optimization_available;
FLGR_MorphoOptim flgr2d_get_optimization_available(FLGR_Data2D *datdest, FLGR_Data2D *datsrc, FLGR_Data2D *nhb);

%feature("autodoc","""
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Apply a scan method on a neighborhood definition.
Some nhb values are unset to satisfy the raster scan direction.
Used for recursive image processing function (geodesic, labelling, distance, ...)
""") flgr2d_apply_raster_scan_method;
FLGR_Ret flgr2d_apply_raster_scan_method(FLGR_Data2D *nhb);

%feature("autodoc","""
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Apply a anti_raster scan method on a neighborhood definition.
Some nhb values are unset to satisfy the anti-raster scan direction
Used for recursive image processing function (geodesic, labelling, distance, ...)
""") flgr2d_apply_anti_raster_scan_method;
FLGR_Ret flgr2d_apply_anti_raster_scan_method(FLGR_Data2D *nhb);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Fill destination from an odd 6-connexity neighborhood declaration to an even neighborhood
""") flgr2d_fill_nhb_even_rows;
FLGR_Ret flgr2d_fill_nhb_even_rows(FLGR_Data2D *nhbdest, FLGR_Data2D *nhbsrc);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Fill destination from an even 6-connexity neighborhood declaration to an odd neighborhood
""") flgr2d_fill_nhb_odd_rows;
FLGR_Ret flgr2d_fill_nhb_odd_rows(FLGR_Data2D *nhbdest, FLGR_Data2D *nhbsrc);

%feature("autodoc","""
[out] FLGR_Data1D destination (must be mono channel)
[in] FLGR_Data1D source
[in] channel index 0..datdest.spp-1
[return] FLGR_Ret\n
Extract a specific channel of a multi channel 1d data
""") flgr1d_extract_channel;
FLGR_Ret flgr1d_extract_channel(FLGR_Data1D *datdest, FLGR_Data1D *datsrc, int channel);

%feature("autodoc","""
[out] FLGR_Data1D destination
[in] FLGR_Data1D source (must be mono channel)
[in] channel index 0..datdest.spp-1
[return] FLGR_Ret\n
Insert a specific channel in a multi channel 1d data
""") flgr1d_compose_channel;
FLGR_Ret flgr1d_compose_channel(FLGR_Data1D *datdest, FLGR_Data1D *datsrc, int channel);

%feature("autodoc","""
[inout] FLGR_Data1D
[return] FLGR_Ret\n
Convert a multi-channel data to a mono-channel
""") flgr1d_pack_channel;
FLGR_Ret flgr1d_pack_channel(FLGR_Data1D *dat);

%feature("autodoc","""
[inout] FLGR_Data1D
[in] Integer : number of channel
[return] FLGR_Ret\n
Convert a mono-channel data to a multi-channel one
""") flgr1d_unpack_channel;
FLGR_Ret flgr1d_unpack_channel(FLGR_Data1D *dat, int factor);

%feature("autodoc","""
[out] FLGR_Data1D
[in] FLGR_Data1D
[return] FLGR_Ret\n
revert channel order
""") flgr1d_revert_channel;
FLGR_Ret flgr1d_revert_channel(FLGR_Data1D *datdest, FLGR_Data1D *datsrc);

%feature("autodoc","""
[out] FLGR_Data1D
[in] FLGR_Data1D
[return] FLGR_Ret\n
get mean of channels
""") flgr1d_mean_channel;
FLGR_Ret flgr1d_mean_channel(FLGR_Data1D *datdest, FLGR_Data1D *datsrc);

%feature("autodoc","""
[out] FLGR_Data2D destination (must be mono channel)
[in] FLGR_Data2D source
[in] channel index 0..datdest.spp-1
[return] FLGR_Ret\n
Extract a specific channel of a multi channel 2d data
""") flgr2d_extract_channel;
FLGR_Ret flgr2d_extract_channel(FLGR_Data2D *datdest, FLGR_Data2D *datsrc, int channel);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data2D source (must be mono channel)
[in] channel index 0..datdest.spp-1
[return] FLGR_Ret\n
Insert a specific channel in a multi channel 2d data
""") flgr2d_compose_channel;
FLGR_Ret flgr2d_compose_channel(FLGR_Data2D *datdest, FLGR_Data2D *datsrc, int channel);

%feature("autodoc","""
[inout] FLGR_Data2D
[return] FLGR_Ret\n
Convert a multi-channel data to a mono-channel
""") flgr2d_pack_channel;
FLGR_Ret flgr2d_pack_channel(FLGR_Data2D *dat);

%feature("autodoc","""
[inout] FLGR_Data2D
[in] Integer : number of channel
[return] FLGR_Ret\n
Convert a mono-channel data to a multi-channel one
""") flgr2d_unpack_channel;
FLGR_Ret flgr2d_unpack_channel(FLGR_Data2D *dat, int factor);

%feature("autodoc","""
[out] FLGR_Data2D
[in] FLGR_Data2D
[return] FLGR_Ret\n
revert channel order
""") flgr2d_revert_channel;
FLGR_Ret flgr2d_revert_channel(FLGR_Data2D *datdest, FLGR_Data2D *datsrc);

%feature("autodoc","""
[inout] FLGR_Data2D
[return] FLGR_Ret\n
revert channel order inplace
""") flgr2d_revert_channel_hmorph;
FLGR_Ret flgr2d_revert_channel_hmorph(FLGR_Data2D *dat);

%feature("autodoc","""
[out] FLGR_Data2D
[in] FLGR_Data2D
[return] FLGR_Ret\n
get mean of channels
""") flgr2d_mean_channel;
FLGR_Ret flgr2d_mean_channel(FLGR_Data2D *datdest, FLGR_Data2D *datsrc);


%feature("autodoc","""
[out] FLGR_Data1D larger than source
[in] FLGR_Data1D source
[in] start index to insert region
Insert a signal
""") flgr1d_insert_region;
FLGR_Ret flgr1d_insert_region(FLGR_Data1D *datdest, FLGR_Data1D *datroi, int x);

%feature("autodoc","""
[out] FLGR_Data1D smaller than source
[in] FLGR_Data1D source
[in] start index of the part to extract\n
Extract a part of a signal
""") flgr1d_extract_region;
FLGR_Ret flgr1d_extract_region(FLGR_Data1D *datroi, FLGR_Data1D *datsrc, int x);

%feature("autodoc","""
[out] FLGR_Data2D larger than source
[in] FLGR_Data2D source
[in] col
[in] row\n
Insert an image
""") flgr2d_insert_region;
FLGR_Ret flgr2d_insert_region(FLGR_Data2D *datdest, FLGR_Data2D *datroi, int x, int y);

%feature("autodoc","""
[out] FLGR_Data2D smaller than source
[in] FLGR_Data2D source
[in] col
[in] row\n
Extract a part of an image
""") flgr2d_extract_region;
FLGR_Ret flgr2d_extract_region(FLGR_Data2D *datroi, FLGR_Data2D *datsrc, int x, int y);

%feature("autodoc","""
[out] FLGR_Data1D destination
[in] FLGR_Data1D source
[in] downsampling factor
downsample a signal
""") flgr1d_downsample;
FLGR_Ret flgr1d_downsample(FLGR_Data1D *datdest, FLGR_Data1D *datsrc, int factor);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data2D source
[in] downsampling factor X
[in] downsampling factor Y
downsample a data2d
""") flgr2d_downsample;
FLGR_Ret flgr2d_downsample(FLGR_Data2D *datdest, FLGR_Data2D *datsrc, int factor_x, int factor_y);


%callback("CB_%(upper)s");


%feature("autodoc","""
[out] FLGR_Data1D destination
[in] FLGR_Data1D source
[return] FLGR_Ret\n
Convert an YUV line to a RGB line
""") flgr1d_color_convert_RGB_YUV;
FLGR_Ret flgr1d_color_convert_RGB_YUV(FLGR_Data1D *datdest, FLGR_Data1D *datsrc);

%feature("autodoc","""
[out] FLGR_Data1D destination
[in] FLGR_Data1D source
[return] FLGR_Ret\n
Convert a RGB line to an YUV line
""") flgr1d_color_convert_YUV_RGB;
FLGR_Ret flgr1d_color_convert_YUV_RGB(FLGR_Data1D *datdest, FLGR_Data1D *datsrc);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Convert an YUV image to a  RGB image
""") flgr2d_color_convert_RGB_YUV;
FLGR_Ret flgr2d_color_convert_RGB_YUV (FLGR_Data2D *datdest, FLGR_Data2D *datsrc);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Convert a RGB image to an YUV image
""") flgr2d_color_convert_YUV_RGB;
FLGR_Ret flgr2d_color_convert_YUV_RGB(FLGR_Data2D *datdest, FLGR_Data2D *datsrc);

%feature("autodoc","""
[out] FLGR_Data1D destination
[in] FLGR_Data1D source
[return] FLGR_Ret\n
Copy source to destination by applying a mirror
""") flgr1d_mirror;
FLGR_Ret flgr1d_mirror(FLGR_Data1D *datdest, FLGR_Data1D *datsrc);

%feature("autodoc","""
[out] FLGR_Data1D destination
[in] FLGR_Data1D source
[return] FLGR_Ret\n
Copy source to destination, Types of images could be different (but no strech operation are performed)
""") flgr1d_copy;
FLGR_Ret flgr1d_copy(FLGR_Data1D *datsrc, FLGR_Data1D *datdest);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Copy source to destination, Types of images could be different (but no strech operation are performed)
""") flgr2d_copy;
FLGR_Ret flgr2d_copy(FLGR_Data2D *datsrc, FLGR_Data2D *datdest);

%nocallback;

%feature("autodoc","""
[out] FLGR_Data1D destination
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Copy a 2d data into a 1D data
""") flgr2d_copy;
FLGR_Ret flgr2d_copy_to_1d(FLGR_Data1D *datdest, FLGR_Data2D *datsrc);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data1D source
[return] FLGR_Ret\n
Copy a 1d data into a 2D data
""") flgr1d_copy_to_2d;
FLGR_Ret flgr1d_copy_to_2d(FLGR_Data2D *datdest, FLGR_Data1D *datsrc);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Copy source to destination by applying a mirror regarding a centered horizontal axis
""") flgr_mirror_vertical;
FLGR_Ret flgr2d_mirror_vertical(FLGR_Data2D *datdest, FLGR_Data2D *datsrc);

%feature("autodoc","""
[out] FLGR_Data2D destination
[in] FLGR_Data2D source
[return] FLGR_Ret\n
Copy source to destination by applying a mirror regarding a centered vertical axis
""") flgr_mirror_horizontal;
FLGR_Ret flgr2d_mirror_horizontal(FLGR_Data2D *datdest, FLGR_Data2D *datsrc);

%feature("autodoc","""
[inout] FLGR_Data2D
[return] FLGR_Ret\n
in place vertical mirror.
""") flgr_mirror_vertical_hmorph;
FLGR_Ret flgr2d_mirror_vertical_hmorph(FLGR_Data2D *dat);

%feature("autodoc","""
[inout] FLGR_Data2D
[return] FLGR_Ret\n
in place horizontal mirror.
""") flgr_mirror_horizontal_hmorph;
FLGR_Ret flgr2d_mirror_horizontal_hmorph(FLGR_Data2D *dat);

%feature("autodoc","""
[out] FLGR_Data2D Destination
[in] FLGR_Data2D Source
[return] FLGR_Ret\n
Matrix transposition (corner turn, pi/2 rotation + mirror)
""") flgr2d_transpose;
FLGR_Ret flgr2d_transpose(FLGR_Data2D *datdest, FLGR_Data2D *datsrc);

%feature("autodoc","""
[out] FLGR_Data2D Destination
[in] FLGR_Data2D Source
[in] Integer : shear column center
[in] Integer : shear row center
[in] Float : shear angle
[return] FLGR_Ret\n
Shear horizontally a 2d data. Shifted columns data are loosed.
""") flgr2d_shear_x;
FLGR_Ret flgr2d_shear_x(FLGR_Data2D *datdest, FLGR_Data2D *datsrc, int xc, int yc, fgFLOAT64 angle);

%feature("autodoc","""
[out] FLGR_Data2D Destination
[in] FLGR_Data2D Source
[in] Integer : shear column center
[in] Integer : shear row center
[in] Float : shear angle
[return] FLGR_Ret\n
Shear vertically a 2d data. Shifted rows data are loosed.
""") flgr2d_shear_y;
FLGR_Ret flgr2d_shear_y(FLGR_Data2D *datdest, FLGR_Data2D *datsrc, int xc, int yc, fgFLOAT64 angle);

%feature("autodoc","""
[out] FLGR_Data2D Destination
[in] FLGR_Data2D Source
[in] Integer : shear column center
[in] Integer : shear row center
[in] Float : shear angle
[return] FLGR_Ret\n
Shear horizontally a 2d data. Shifted columns are re-inserted.
""") flgr2d_shear_circular_x;
FLGR_Ret flgr2d_shear_circular_x(FLGR_Data2D *datdest, FLGR_Data2D *datsrc, int xc, int yc, fgFLOAT64 angle);

%feature("autodoc","""
[out] FLGR_Data2D Destination
[in] FLGR_Data2D Source
[in] Integer : shear column center
[in] Integer : shear row center
[in] Float : shear angle
[return] FLGR_Ret\n
Shear vertically a 2d data. Shifted rows data are re-inserted.
""") flgr2d_shear_circular_y;
FLGR_Ret flgr2d_shear_circular_y(FLGR_Data2D *datdest, FLGR_Data2D *datsrc, int xc, int yc, fgFLOAT64 angle);

%feature("autodoc","""
[out] FLGR_Data2D Destination
[in] FLGR_Data2D Source
[in] Float : rotation angle -180..180
[return] FLGR_Ret\n
Rotate 2d data using shear. ?o interpolation are performed.
""") flgr2d_rotate_center;
FLGR_Ret flgr2d_rotate_center(FLGR_Data2D *datdest, FLGR_Data2D *datsrc, fgFLOAT64 angle);

%feature("autodoc","""
[inout] FLGR_Data2D
[return] FLGR_Ret\n
4-connex in-place morphological dilatation.
""") flgr2d_native_dilate_4_connexity;
FLGR_Ret flgr2d_native_dilate_4_connexity(FLGR_Data2D *nhb);

%feature("autodoc","""
[inout] FLGR_Data2D
[return] FLGR_Ret\n
6-connex in-place morphological dilatation.
""") flgr2d_native_dilate_6_connexity;
FLGR_Ret flgr2d_native_dilate_6_connexity(FLGR_Data2D *nhb);

%feature("autodoc","""
[inout] FLGR_Data2D
[return] FLGR_Ret\n
8-connex in-place morphological dilatation.
""") flgr2d_native_dilate_8_connexity;
FLGR_Ret flgr2d_native_dilate_8_connexity(FLGR_Data2D *nhb);



%include "../common/typemap_flgr_vector.i"

%include "flgrcore_compare.i"
%include "flgrcore_shift.i"
%include "flgrcore_stream.i"
%include "flgrcore_geometry.i"
%include "flgrcore_callbacks.i"
%include "flgrcore_threads.i"
